home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 November: Tool Chest / Dev.CD Nov 94.toast / Tool Chest / Development Tools & Languages / Macintosh Common Lisp Related / interfaces / PInterface Translator / PInterfaces / ImageCompression.p < prev    next >
Encoding:
Text File  |  1993-09-16  |  26.9 KB  |  618 lines  |  [TEXT/MPS ]
  1. { All rights reserved
  2.  
  3. Created: Tuesday, October 13, 1992 at 4:31 PM
  4.  ImageCompression.p
  5.  Pascal Interface to the Macintosh Libraries
  6.  
  7.  Copyright Apple Computer, Inc. 1991, 1992
  8.  All rights reserved
  9. }
  10.  
  11.  
  12. {$IFC UNDEFINED UsingIncludes}
  13. {$SETC UsingIncludes := 0}
  14. {$ENDC}
  15.  
  16. {$IFC NOT UsingIncludes}
  17.  UNIT ImageCompression;
  18.  INTERFACE
  19. {$ENDC}
  20.  
  21. {$IFC UNDEFINED UsingImageCompression}
  22. {$SETC UsingImageCompression := 1}
  23.  
  24. {$I+}
  25. {$SETC ImageCompressionIncludes := UsingIncludes}
  26. {$SETC UsingIncludes := 1}
  27. {$IFC UNDEFINED UsingQuickDraw}
  28. {$I $$Shell(PInterfaces)QuickDraw.p}
  29. {$ENDC}
  30. {$IFC UNDEFINED UsingQDOffscreen}
  31. {$I $$Shell(PInterfaces)QDOffscreen.p}
  32. {$ENDC}
  33. {$IFC UNDEFINED UsingTypes}
  34. {$I $$Shell(PInterfaces)Types.p}
  35. {$ENDC}
  36. {$IFC UNDEFINED UsingComponents}
  37. {$I $$Shell(PInterfaces)Components.p}
  38. {$ENDC}
  39. {$IFC UNDEFINED UsingStandardFile}
  40. {$I $$Shell(PInterfaces)StandardFile.p}
  41. {$ENDC}
  42. {$SETC UsingIncludes := ImageCompressionIncludes}
  43.  
  44. CONST
  45. gestaltCompressionMgr = 'icmp';
  46.  
  47. TYPE
  48. {  Matrix stuff  }
  49. MatrixRecord = RECORD
  50.  matrix: ARRAY [0..2,0..2] OF Fixed;
  51.  END;
  52. MatrixRecordPtr = ^MatrixRecord;
  53.  
  54. FixedPoint = RECORD
  55.  x: Fixed;
  56.  y: Fixed;
  57.  END;
  58.  
  59. FixedRect = RECORD
  60.  left: Fixed;
  61.  top: Fixed;
  62.  right: Fixed;
  63.  bottom: Fixed;
  64.  END;
  65.  
  66. CONST
  67. { These are the bits that are set in the Component flags, and also in the codecInfo struct. }
  68.  
  69. codecInfoDoes1 = $1;                    { codec can work with 1-bit pixels }
  70. codecInfoDoes2 = $2;                    { codec can work with 2-bit pixels }
  71. codecInfoDoes4 = $4;                    { codec can work with 4-bit pixels }
  72. codecInfoDoes8 = $8;                    { codec can work with 8-bit pixels }
  73. codecInfoDoes16 = $10;                    { codec can work with 16-bit pixels }
  74. codecInfoDoes32 = $20;                    { codec can work with 32-bit pixels }
  75. codecInfoDoesDither = $40;                { codec can do ditherMode }
  76. codecInfoDoesStretch = $80;                { codec can stretch to arbitrary sizes }
  77. codecInfoDoesShrink = $100;                { codec can shrink to arbitrary sizes }
  78. codecInfoDoesMask = $200;                { codec can mask to clipping regions }
  79.  
  80. codecInfoDoesTemporal = $400;            { codec can handle temporal redundancy }
  81.  
  82. codecInfoDoesDouble = $800;                { codec can stretch to double size exactly }
  83. codecInfoDoesQuad = $1000;                { codec can stretch to quadruple size exactly }
  84. codecInfoDoesHalf = $2000;                { codec can shrink to half size }
  85. codecInfoDoesQuarter = $4000;            { codec can shrink to quarter size }
  86.  
  87. codecInfoDoesRotate = $8000;            { codec can rotate on decompress }
  88. codecInfoDoesHorizFlip = $10000;        { codec can flip horizontally on decompress }
  89. codecInfoDoesVertFlip = $20000;            { codec can flip vertically on decompress }
  90. codecInfoDoesSkew = $40000;                { codec can skew on decompress }
  91. codecInfoDoesBlend = $80000;            { codec can blend on decompress }
  92. codecInfoDoesWarp = $100000;            { codec can warp arbitrarily on decompress }
  93. codecInfoDoesRecompress = $200000;        { codec can recompress image without accumulating errors }
  94. codecInfoDoesSpool = $400000;            { codec can spool image data }
  95. codecInfoDoesRateConstrain = $800000;
  96.  
  97. codecInfoDepth1 = $1;                    { compressed data at 1 bpp depth available }
  98. codecInfoDepth2 = $2;                    { compressed data at 2 bpp depth available }
  99. codecInfoDepth4 = $4;                    { compressed data at 4 bpp depth available }
  100. codecInfoDepth8 = $8;                    { compressed data at 8 bpp depth available }
  101. codecInfoDepth16 = $10;                    { compressed data at 16 bpp depth available }
  102. codecInfoDepth32 = $20;                    { compressed data at 32 bpp depth available }
  103. codecInfoDepth24 = $40;                    { compressed data at 24 bpp depth available }
  104. codecInfoDepth33 = $80;                    { compressed data at 1 bpp monochrome depth  available }
  105. codecInfoDepth34 = $100;                { compressed data at 2 bpp grayscale depth available }
  106. codecInfoDepth36 = $200;                { compressed data at 4 bpp grayscale depth available }
  107. codecInfoDepth40 = $400;                { compressed data at 8 bpp grayscale depth available }
  108. codecInfoStoresClut = $800;                { compressed data can have custom cluts }
  109. codecInfoDoesLossless = $1000;            { compressed data can be stored in lossless format }
  110. codecInfoSequenceSensitive = $2000;
  111.  
  112. codecFlagUseImageBuffer = $1;            { (input) allocate buffer for whole image on decompress sequence }
  113. codecFlagUseScreenBuffer = $2;            { (input) allocate buffer for screen on decompress sequence for faster updates }
  114. codecFlagUpdatePrevious = $4;            { (input) udate previous buffer on compress sequence }
  115. codecFlagNoScreenUpdate = $8;            { (input) dont update screen, but do update image buffer if allocated }
  116. codecFlagWasCompressed = $10;            { (input) hint to compressor that image was previously compressed }
  117. codecFlagDontOffscreen = $20;            { (input) return error instead of automatically going offscreen }
  118. codecFlagUpdatePreviousComp = $40;        { (input) udate previous buffer on compress sequence }
  119. codecFlagForceKeyFrame = $80;            { (input) when sent to CompressSequenceFrame, forces that frame to be a key frame }
  120. codecFlagOnlyScreenUpdate = $100;        { (input) only update screen from }
  121. codecFlagLiveGrab    = $200;                { (input) data being compressed is from live source (speed is critical) }
  122. codecFlagDontUseNewImageBuffer = $400;     { (input) return error if image buffer is new or reallocated }
  123. codecFlagInterlaceUpdate = $800;        { (input) use interlaced update }
  124.  
  125.  
  126. codecFlagUsedNewImageBuffer    = $4000;    { (output) indicates that image buffer was first used on this decompress sequence }
  127. codecFlagUsedImageBuffer = $8000;        { (output) indicates that image buffer was used on this decompress sequence }
  128.  
  129. codecErr = -8960;                        { the codec returned an error }
  130. noCodecErr = -8961;                        { the specified codec could not be found }
  131. codecUnimpErr = -8962;                    { this feature is not implemented by the specified codec }
  132. codecSizeErr = -8963;
  133. codecScreenBufErr = -8964;                { the screen buffer could not be allocated }
  134. codecImageBufErr = -8965;                { the image buffer could not be allocated }
  135. codecSpoolErr = -8966;                    { the compressed data must be in memory (spooling did not work) }
  136. codecAbortErr = -8967;                    { the operation was aborted by the progress proc }
  137. codecWouldOffscreenErr = -8968;            { an offscreen access would have been used, but wasn't allowed because codecFlagDontOffscreen was set }
  138. codecBadDataErr = -8969;                { compressed data was found to have inconsistencies }
  139. codecDataVersErr = -8970;                { compressed data was of a format version that codec couldn't handle }
  140. codecExtensionNotFoundErr = -8971;
  141. codecConditionErr = -8972;                { codec can not do requested operation }
  142. codecOpenErr = -8973;                    { the codec  could not be opened }
  143.  
  144. codecMinimumDataSize = 32768;            { The minimum data size for spooling in or out data }
  145.  
  146. compressorComponentType = 'imco';        { the type for "Components" which compress images }
  147. decompressorComponentType = 'imdc';        { the type for "Components" which decompress images }
  148.  
  149. TYPE
  150. CompressorComponent = Component;        { a Component which compresses images }
  151. DecompressorComponent = Component;        { a Component which decompresses images }
  152. CodecComponent = Component;                { a Component which decompresses or compresses images }
  153.  
  154. CONST
  155. anyCodec                 =  0;            { take first working codec of given type }
  156. bestSpeedCodec             = -1;            { take fastest codec of given type }
  157. bestFidelityCodec        = -2;            { take codec which is most accurate}
  158. bestCompressionCodec    = -3;            { take codec of given type that is most accurate }
  159.  
  160. TYPE
  161. CodecType = OsType;                    { type descriptor for codecs i.e: 'appl','jpeg','rle ' }
  162.  
  163. CodecFlags = INTEGER;                    { flags for codec manager calls }
  164.  
  165. CodecQ = LONGINT;
  166.  
  167. CONST
  168. codecLosslessQuality    = $400;
  169. codecMaxQuality            = $3FF;
  170. codecMinQuality            = $000;
  171. codecLowQuality            = $100;
  172. codecNormalQuality        = $200;
  173. codecHighQuality        = $300;
  174.  
  175. TYPE
  176. DataProcPtr = ProcPtr;
  177. FlushProcPtr = ProcPtr;
  178. CompletionProcPtr = ProcPtr;
  179.  
  180. CONST
  181. codecCompletionSource = 1;                { asynchronous codec is done with source data  }
  182. codecCompletionDest = 2;                { asynchronous codec is done with destination data  }
  183.  
  184. TYPE
  185. ProgressProcPtr = ProcPtr;
  186.  
  187. CONST
  188. codecProgressOpen = 0;
  189. codecProgressUpdatePercent = 1;
  190. codecProgressClose = 2;
  191.  
  192. TYPE
  193. StdPixProcPtr = ProcPtr;
  194.  
  195. ImageSequence = LONGINT;
  196.  
  197. ProgressProcRecordPtr = ^ProgressProcRecord;
  198. ProgressProcRecord = RECORD
  199.  progressProc: ProgressProcPtr;
  200.  progressRefCon: LONGINT;
  201.  END;
  202.  
  203. CompletionProcRecordPtr = ^CompletionProcRecord;
  204. CompletionProcRecord = RECORD
  205.  completionProc: CompletionProcPtr;
  206.  completionRefCon: LONGINT;
  207.  END;
  208.  
  209. DataProcRecordPtr = ^DataProcRecord;
  210. DataProcRecord = RECORD
  211.  dataProc: DataProcPtr;
  212.  dataRefCon: LONGINT;
  213.  END;
  214.  
  215. FlushProcRecordPtr = ^FlushProcRecord;
  216. FlushProcRecord = RECORD
  217.  flushProc: FlushProcPtr;
  218.  flushRefCon: LONGINT;
  219.  END;
  220.  
  221.  
  222. AlignmentProcPtr = ProcPtr;
  223.  
  224. AlignmentProcRecordPtr = ^AlignmentProcRecord;
  225. AlignmentProcRecord = RECORD
  226.     alignmentProc: AlignmentProcPtr;
  227.     alignmentRefCon: LONGINT;
  228.  END;
  229.  
  230. DataRateParamsPtr = ^DataRateParams;
  231. DataRateParams = RECORD
  232.     dataRate: LONGINT;
  233.     dataOverrun: LONGINT;
  234.     frameDuration: LONGINT;
  235.     keyFrameRate: LONGINT;
  236.     minSpatialQuality: CodecQ;
  237.     minTemporalQuality: CodecQ;
  238.  END;
  239.  
  240.  
  241. { 
  242.     The ImageDescription is private data which is produced when an image or sequence 
  243.     is compressed. It fully describes the format of the compressed data.}
  244.  
  245. ImageDescriptionPtr = ^ImageDescription;
  246. ImageDescriptionHandle = ^ImageDescriptionPtr;
  247. ImageDescription = PACKED RECORD
  248.  idSize: LONGINT;                        { total size of ImageDescription including extra data ( CLUTs and other per sequence data }
  249.  cType: CodecType;                        { what kind of codec compressed this data }
  250.  resvd1: LONGINT;                        { reserved for apple use }
  251.  resvd2: INTEGER;                        { reserved for apple use }
  252.  dataRefIndex: INTEGER;                    { set to zero }
  253.  version: INTEGER;                        { which version is this data }
  254.  revisionLevel: INTEGER;                { what version of that codec did this }
  255.  vendor: LONGINT;                        { whose  codec compressed this data }
  256.  temporalQuality: CodecQ;                { what was the temporal quality factor          }
  257.  spatialQuality: CodecQ;                { what was the spatial quality factor          }
  258.  width: INTEGER;                        { how many pixels wide is this data }
  259.  height: INTEGER;                        { how many pixels high is this data }
  260.  hRes: Fixed;                            { horizontal resolution }
  261.  vRes: Fixed;                            { vertical resolution }
  262.  dataSize: LONGINT;                        { if known, the size of data for this image descriptor }
  263.  frameCount: INTEGER;                    { number of frames this description applies to }
  264.  name: PACKED ARRAY [0..31] OF CHAR;    { name of codec ( in case not installed ) }
  265.  depth: INTEGER;                        { what depth is this data (1-32) or ( 33-40 grayscale ) }
  266.  clutID: INTEGER;                        { clut id or if 0 clut follows  or -1 if no clut }
  267.  END;
  268.  
  269. { 
  270.     The CodecInfo is the information returned as the codecInfo struct by a codec Component
  271.     to the codec manager or to the caller. It is specific to the particular codec
  272.     implementation and not to the codec type.}
  273.  
  274. CodecInfo = PACKED RECORD
  275.  typeName: PACKED ARRAY [0..31] OF CHAR;{ name of the codec type i.e.: 'Apple Image Compression' }
  276.  version: INTEGER;                        { version of the codec data that this codec knows about }
  277.  revisionLevel: INTEGER;                { revision level of this codec i.e: 0x00010001 (1.0.1) }
  278.  vendor: LONGINT;                        { Maker of this codec i.e: 'appl' }
  279.  decompressFlags: LONGINT;                { codecInfo flags for decompression capabilities }
  280.  compressFlags: LONGINT;                { codecInfo flags for compression capabilities }
  281.  formatFlags: LONGINT;                    { codecInfo flags for compression format details }
  282.  compressionAccuracy: CHAR;                { measure (1-255) of accuracy of this codec for compress (0 if unknown) }
  283.  decompressionAccuracy: CHAR;            { measure (1-255) of accuracy of this codec for decompress (0 if unknown) }
  284.  compressionSpeed: INTEGER;                { ( millisecs for compressing 320x240 on base mac II) (0 if unknown) }
  285.  decompressionSpeed: INTEGER;            { ( millisecs for decompressing 320x240 on mac II)(0 if unknown) }
  286.  compressionLevel: CHAR;                { measure (1-255) of compression level of this codec (0 if unknown) }
  287.  resvd: CHAR;                            { pad }
  288.  minimumHeight: INTEGER;                { minimum height of image (block size) }
  289.  minimumWidth: INTEGER;                    { minimum width of image (block size) }
  290.  decompressPipelineLatency: INTEGER;    { in milliseconds ( for asynchronous codecs ) }
  291.  compressPipelineLatency: INTEGER;        { in milliseconds ( for asynchronous codecs ) }
  292.  privateData: LONGINT;
  293.  END;
  294.  
  295. { Name list returned by GetCodecNameList. }
  296. CodecNameSpec = PACKED RECORD
  297.  codec: CodecComponent;
  298.  cType: CodecType;
  299.  typeName: PACKED ARRAY [0..31] OF CHAR;
  300.  name: Handle;
  301.  END;
  302.  
  303. CodecNameSpecListPtr = ^CodecNameSpecList;
  304. CodecNameSpecList = RECORD
  305.  count: INTEGER;
  306.  list: ARRAY [0..0] OF CodecNameSpec;
  307.  END;
  308.  
  309. CONST
  310. defaultDither    = 0;
  311. forceDither        = 1;
  312. suppressDither    = 2;
  313.  
  314.  
  315. FUNCTION CodecManagerVersion(VAR version: LONGINT): OSErr;
  316.  INLINE $7000,$AAA3;
  317. FUNCTION GetCodecNameList(VAR list: CodecNameSpecListPtr;showAll: INTEGER): OSErr;
  318.  INLINE $7001,$AAA3;
  319. FUNCTION DisposeCodecNameList(list: CodecNameSpecListPtr): OSErr;
  320. INLINE  $700F,$AAA3;
  321. FUNCTION GetCodecInfo(VAR info: CodecInfo;cType: CodecType;codec: CodecComponent): OSErr;
  322.  INLINE $7003,$AAA3;
  323. FUNCTION GetMaxCompressionSize(src: PixMapHandle;srcRect: Rect;colorDepth: INTEGER;
  324.  quality: CodecQ;cType: CodecType;codec: CompressorComponent;VAR size: LONGINT): OSErr;
  325.  INLINE $7004,$AAA3;
  326. FUNCTION GetCompressionTime(src: PixMapHandle; srcRect: Rect;colorDepth: INTEGER;
  327.  cType: CodecType;codec: CompressorComponent;VAR spatialQuality: CodecQ;
  328.  VAR temporalQuality: CodecQ;VAR compressTime: LONGINT): OSErr;
  329.  INLINE $7005,$AAA3;
  330. FUNCTION CompressImage(src: PixMapHandle; srcRect: Rect;quality: CodecQ;
  331.  cType: CodecType;desc: ImageDescriptionHandle;data: Ptr): OSErr;
  332.  INLINE $7006,$AAA3;
  333. FUNCTION FCompressImage(src: PixMapHandle; srcRect: Rect;colorDepth: INTEGER;
  334.  quality: CodecQ;cType: CodecType;codec: CompressorComponent;clut: CTabHandle;
  335.  flags: CodecFlags;bufferSize: LONGINT;flushProc: FlushProcRecordPtr;progressProc: ProgressProcRecordPtr;
  336.  desc: ImageDescriptionHandle;data: Ptr): OSErr;
  337.  INLINE $7007,$AAA3;
  338. FUNCTION DecompressImage(data: Ptr;desc: ImageDescriptionHandle;dst: PixMapHandle;
  339.   srcRect: Rect; dstRect: Rect;mode: INTEGER;mask: RgnHandle): OSErr;
  340.  INLINE $7008,$AAA3;
  341. FUNCTION FDecompressImage(data: Ptr;desc: ImageDescriptionHandle;dst: PixMapHandle;
  342.   srcRect: Rect;matrix: MatrixRecordPtr;mode: INTEGER;mask: RgnHandle;
  343.  matte: PixMapHandle; matteRect: Rect;accuracy: CodecQ;codec: DecompressorComponent;
  344.  bufferSize: LONGINT;dataProc: DataProcRecordPtr;progressProc: ProgressProcRecordPtr): OSErr;
  345.  INLINE $7009,$AAA3;
  346. FUNCTION CompressSequenceBegin(VAR seqID: ImageSequence;src: PixMapHandle;
  347.  prev: PixMapHandle; srcRect: Rect; prevRect: Rect;colorDepth: INTEGER;
  348.  cType: CodecType;codec: CompressorComponent;spatialQuality: CodecQ;temporalQuality: CodecQ;
  349.  keyFrameRate: LONGINT;clut: CTabHandle;flags: CodecFlags;desc: ImageDescriptionHandle): OSErr;
  350.  INLINE $700A,$AAA3;
  351. FUNCTION CompressSequenceFrame(seqID: ImageSequence;src: PixMapHandle; srcRect: Rect;
  352.  flags: CodecFlags;data: Ptr;VAR dataSize: LONGINT;VAR similarity: Byte;
  353.  asyncCompletionProc: CompletionProcRecordPtr): OSErr;
  354.   INLINE $206F,$0004,$4250,$52AF,$0004,$700B,$AAA3;
  355. FUNCTION DecompressSequenceBegin(VAR seqID: ImageSequence;desc: ImageDescriptionHandle;
  356.  port: CGrafPtr;gdh: GDHandle; srcRect: Rect;matrix: MatrixRecordPtr;
  357.  mode: INTEGER;mask: RgnHandle;flags: CodecFlags;accuracy: CodecQ;codec: DecompressorComponent): OSErr;
  358.  INLINE $700D,$AAA3;
  359. FUNCTION DecompressSequenceFrame(seqID: ImageSequence;data: Ptr;inFlags: CodecFlags;
  360.  VAR outFlags: CodecFlags;asyncCompletionProc: CompletionProcRecordPtr): OSErr;
  361.  INLINE $700E,$AAA3;
  362. FUNCTION SetDSequenceMatrix(seqID: ImageSequence;matrix: MatrixRecordPtr): OSErr;
  363.  INLINE $7010,$AAA3;
  364. FUNCTION SetDSequenceMatte(seqID: ImageSequence;matte: PixMapHandle; matteRect: Rect): OSErr;
  365.  INLINE $7011,$AAA3;
  366. FUNCTION SetDSequenceMask(seqID: ImageSequence;mask: RgnHandle): OSErr;
  367.  INLINE $7012,$AAA3;
  368. FUNCTION SetDSequenceTransferMode(seqID: ImageSequence;mode: INTEGER; opColor: RGBColor): OSErr;
  369.  INLINE $7013,$AAA3;
  370. FUNCTION SetDSequenceDataProc(seqID: ImageSequence;dataProc: DataProcRecordPtr;
  371.  bufferSize: LONGINT): OSErr;
  372.  INLINE $7014,$AAA3;
  373. FUNCTION SetDSequenceAccuracy(seqID: ImageSequence;accuracy: CodecQ): OSErr;
  374.  INLINE $7034,$AAA3;
  375. FUNCTION SetDSequenceSrcRect(seqID: ImageSequence; srcRect: Rect): OSErr;
  376.  INLINE $7035,$AAA3;
  377. FUNCTION GetDSequenceImageBuffer(seqID: ImageSequence;VAR gworld: GWorldPtr): OSErr;
  378.  INLINE $7015,$AAA3;
  379. FUNCTION GetDSequenceScreenBuffer(seqID: ImageSequence;VAR gworld: GWorldPtr): OSErr;
  380.  INLINE $7016,$AAA3;
  381. FUNCTION SetCSequenceQuality(seqID: ImageSequence;spatialQuality: CodecQ;
  382.  temporalQuality: CodecQ): OSErr;
  383.  INLINE $7017,$AAA3;
  384. FUNCTION SetCSequencePrev(seqID: ImageSequence;prev: PixMapHandle; prevRect: Rect): OSErr;
  385.  INLINE $7018,$AAA3;
  386. FUNCTION SetCSequenceFlushProc(seqID: ImageSequence;flushProc: FlushProcRecordPtr;
  387.  bufferSize: LONGINT): OSErr;
  388.  INLINE $7033,$AAA3;
  389. FUNCTION SetCSequenceKeyFrameRate(seqID: ImageSequence;keyframerate: LONGINT): OSErr;
  390.  INLINE $7036,$AAA3;
  391. FUNCTION GetCSequenceKeyFrameRate(seqID: ImageSequence; VAR keyframerate: LONGINT): OSErr;
  392.  INLINE $203C,12,75,$AAA3;
  393. FUNCTION GetCSequencePrevBuffer(seqID: ImageSequence;VAR gworld: GWorldPtr): OSErr;
  394.  INLINE $7019,$AAA3;
  395. FUNCTION CDSequenceBusy(seqID: ImageSequence): OSErr;
  396.  INLINE $701A,$AAA3;
  397. FUNCTION CDSequenceEnd(seqID: ImageSequence): OSErr;
  398.  INLINE $701B,$AAA3;
  399. FUNCTION GetCompressedImageSize(desc: ImageDescriptionHandle;data: Ptr;
  400.  bufferSize: LONGINT;dataProc: DataProcRecordPtr;VAR dataSize: LONGINT): OSErr;
  401.  INLINE $701C,$AAA3;
  402. FUNCTION GetSimilarity(src: PixMapHandle; srcRect: Rect;desc: ImageDescriptionHandle;
  403.  data: Ptr;VAR similarity: Fixed): OSErr;
  404.  INLINE $701D,$AAA3;
  405. FUNCTION GetImageDescriptionCTable(desc: ImageDescriptionHandle;VAR ctable: CTabHandle): OSErr;
  406.  INLINE $701E,$AAA3;
  407. FUNCTION SetImageDescriptionCTable(desc: ImageDescriptionHandle;ctable: CTabHandle): OSErr;
  408.  INLINE $701F,$AAA3;
  409. FUNCTION GetImageDescriptionExtension(desc: ImageDescriptionHandle;VAR extension: Handle;
  410.  idType: LONGINT;index: LONGINT): OSErr;
  411.  INLINE $7020,$AAA3;
  412. FUNCTION SetImageDescriptionExtension(desc: ImageDescriptionHandle;extension: Handle;
  413.  idType: LONGINT): OSErr;
  414.  INLINE $7021,$AAA3;
  415. FUNCTION RemoveImageDescriptionExtension(desc: ImageDescriptionHandle; idType: LONGINT; index: LONGINT): OSErr;
  416.  INLINE $203C,12,$003A,$AAA3;
  417. FUNCTION CountImageDescriptionExtensionType(desc: ImageDescriptionHandle; idType: LONGINT; VAR count: LONGINT): OSErr;
  418.  INLINE $203C,12,$003B,$AAA3;
  419. FUNCTION GetNextImageDescriptionExtensionType(desc: ImageDescriptionHandle; VAR idType: LONGINT): OSErr;
  420.  INLINE $203C,8,$003C,$AAA3;
  421. FUNCTION FindCodec(cType: CodecType;specCodec: CodecComponent;VAR compressor: CompressorComponent;
  422.  VAR decompressor: DecompressorComponent): OSErr;
  423.  INLINE $7023,$AAA3;
  424. FUNCTION CompressPicture(srcPicture: PicHandle;dstPicture: PicHandle;quality: CodecQ;
  425.  cType: CodecType): OSErr;
  426.  INLINE $7024,$AAA3;
  427. FUNCTION FCompressPicture(srcPicture: PicHandle;dstPicture: PicHandle;colorDepth: INTEGER;
  428.  clut: CTabHandle;quality: CodecQ;doDither: INTEGER;compressAgain: INTEGER;
  429.  progressProc: ProgressProcRecordPtr;cType: CodecType;codec: CompressorComponent): OSErr;
  430.  INLINE $7025,$AAA3;
  431. FUNCTION CompressPictureFile(srcRefNum: INTEGER;dstRefNum: INTEGER;quality: CodecQ;
  432.  cType: CodecType): OSErr;
  433.  INLINE $7026,$AAA3;
  434. FUNCTION FCompressPictureFile(srcRefNum: INTEGER;dstRefNum: INTEGER;colorDepth: INTEGER;
  435.  clut: CTabHandle;quality: CodecQ;doDither: INTEGER;compressAgain: INTEGER;
  436.  progressProc: ProgressProcRecordPtr;cType: CodecType;codec: CompressorComponent): OSErr;
  437.  INLINE $7027,$AAA3;
  438. FUNCTION GetPictureFileHeader(refNum: INTEGER;VAR frame: Rect;VAR header: OpenCPicParams): OSErr;
  439.  INLINE $7028,$AAA3;
  440. FUNCTION DrawPictureFile(refNum: INTEGER; frame: Rect;progressProc: ProgressProcRecordPtr): OSErr;
  441.  INLINE $7029,$AAA3;
  442. FUNCTION DrawTrimmedPicture(srcPicture: PicHandle; frame: Rect;trimMask: RgnHandle;
  443.  doDither: INTEGER;progressProc: ProgressProcRecordPtr): OSErr;
  444.  INLINE $702E,$AAA3;
  445. FUNCTION DrawTrimmedPictureFile(srcRefnum: INTEGER; frame: Rect;trimMask: RgnHandle;
  446.  doDither: INTEGER;progressProc: ProgressProcRecordPtr): OSErr;
  447.  INLINE $702F,$AAA3;
  448. FUNCTION MakeThumbnailFromPicture(picture: PicHandle;colorDepth: INTEGER;
  449.  thumbnail: PicHandle;progressProc: ProgressProcRecordPtr): OSErr;
  450.  INLINE $702A,$AAA3;
  451. FUNCTION MakeThumbnailFromPictureFile(refNum: INTEGER;colorDepth: INTEGER;
  452.  thumbnail: PicHandle;progressProc: ProgressProcRecordPtr): OSErr;
  453.  INLINE $702B,$AAA3;
  454. FUNCTION MakeThumbnailFromPixMap(src: PixMapHandle; srcRect: Rect;colorDepth: INTEGER;
  455.  thumbnail: PicHandle;progressProc: ProgressProcRecordPtr): OSErr;
  456.  INLINE $702C,$AAA3;
  457. FUNCTION TrimImage(desc: ImageDescriptionHandle;inData: Ptr;inBufferSize: LONGINT;
  458.  dataProc: DataProcRecordPtr;outData: Ptr;outBufferSize: LONGINT;flushProc: FlushProcRecordPtr;
  459.   VAR trimRect: Rect;progressProc: ProgressProcRecordPtr): OSErr;
  460.  INLINE $702D,$AAA3;
  461. FUNCTION ConvertImage(srcDD: ImageDescriptionHandle;srcData: Ptr;colorDepth: INTEGER;
  462.  clut: CTabHandle;accuracy: CodecQ;quality: CodecQ;cType: CodecType;codec: CodecComponent;
  463.  dstDD: ImageDescriptionHandle;dstData: Ptr): OSErr;
  464.  INLINE $7030,$AAA3;
  465. FUNCTION GetCompressedPixMapInfo(pix: PixMapPtr;VAR desc: ImageDescriptionHandle;
  466.  VAR data: Ptr;VAR bufferSize: LONGINT;VAR dataProc: DataProcRecord;VAR progressProc: ProgressProcRecord): OSErr;
  467.  INLINE $7037,$AAA3;
  468. FUNCTION SetCompressedPixMapInfo(pix: PixMapPtr;desc: ImageDescriptionHandle;
  469.  data: Ptr;bufferSize: LONGINT;dataProc: DataProcRecordPtr;progressProc: ProgressProcRecordPtr): OSErr;
  470.  INLINE $7038,$AAA3;
  471. FUNCTION StdPix( src: PixMapPtr;  srcRect :Rect; matrix : MatrixRecordPtr; mode : INTEGER;
  472.     mask: RgnHandle ;  matte: PixMapPtr;  matteRect: Rect; flags : INTEGER ) : OSErr;
  473. INLINE $700C,$AAA3;
  474.  
  475. {   Standard Preview  }
  476.  
  477. PROCEDURE SFGetFilePreview(where: Point;
  478.                     prompt: Str255;
  479.                     fileFilter: FileFilterProcPtr;
  480.                     numTypes: INTEGER;
  481.                     typeList: SFTypeList;
  482.                     dlgHook: DlgHookProcPtr;
  483.                     VAR reply: SFReply);
  484.  INLINE $303C,$41,$AAA3;
  485.  
  486. PROCEDURE SFPGetFilePreview(where: Point;
  487.                      prompt: Str255;
  488.                      fileFilter: FileFilterProcPtr;
  489.                      numTypes: INTEGER;
  490.                      typeList: SFTypeList;
  491.                      dlgHook: DlgHookProcPtr;
  492.                      VAR reply: SFReply;
  493.                      dlgID: INTEGER;
  494.                      filterProc: ModalFilterProcPtr);
  495.  INLINE $303C,$42,$AAA3;
  496.  
  497. PROCEDURE StandardGetFilePreview(fileFilter: FileFilterProcPtr;
  498.                           numTypes: INTEGER;
  499.                           typeList: SFTypeList;
  500.                           VAR reply: StandardFileReply);
  501.  INLINE $303C,$43,$AAA3;
  502.  
  503. PROCEDURE CustomGetFilePreview(fileFilter: FileFilterYDProcPtr;
  504.                         numTypes: INTEGER;
  505.                         typeList: SFTypeList;
  506.                         VAR reply: StandardFileReply;
  507.                         dlgID: INTEGER;
  508.                         where: Point;
  509.                         dlgHook: DlgHookYDProcPtr;
  510.                         filterProc: ModalFilterYDProcPtr;
  511.                         activeList: Ptr;
  512.                         activateProc: ActivateYDProcPtr;
  513.                         yourDataPtr: UNIV Ptr);
  514.  INLINE $303C,$44,$AAA3;
  515.  
  516. FUNCTION MakeFilePreview(resRefNum: INTEGER;  progress: ProgressProcRecordPtr): OSErr;
  517.  INLINE $303C,$45,$AAA3;
  518.  
  519. FUNCTION AddFilePreview(resRefNum: INTEGER; previewType: OSType; previewData: Handle): OSErr;
  520.  INLINE $303C,$46,$AAA3;
  521.  
  522. CONST
  523.     sfpItemPreviewAreaUser = 11;
  524.     sfpItemPreviewStaticText = 12;
  525.     sfpItemPreviewDividerUser = 13;
  526.     sfpItemCreatePreviewButton = 14;
  527.     sfpItemShowPreviewButton = 15;
  528.  
  529. TYPE
  530.  
  531. PreviewResourcePtr = ^PreviewResourceRecord;
  532. PreviewResourceHandle = ^PreviewResourcePtr;
  533. PreviewResourceRecord = RECORD
  534.     modDate : LONGINT;
  535.     version : INTEGER;
  536.     resType : OSType;
  537.     resID : INTEGER;
  538. END;
  539.  
  540. PROCEDURE AlignScreenRect(VAR rp: Rect; alignmentProc:AlignmentProcRecordPtr);
  541.  INLINE $203C,$8,$4C,$AAA3;
  542. PROCEDURE AlignWindow(wp: WindowPtr; front: Boolean; alignmentRect: RectPtr; alignmentProc:AlignmentProcRecordPtr );
  543.  INLINE $203C,$E,$4D,$AAA3;
  544. PROCEDURE DragAlignedWindow(wp: WindowPtr; startPt: Point; VAR boundsRect: Rect; VAR alignmentRect: Rect; alignmentProc:AlignmentProcRecordPtr);
  545.  INLINE $203C,$14,$4E,$AAA3;
  546. FUNCTION DragAlignedGrayRgn(theRgn: RgnHandle; startPt: Point; VAR boundsRect: Rect;
  547.  VAR slopRect: Rect; axis: INTEGER; actionProc: ProcPtr; VAR alignmentRect: Rect; alignmentProc:AlignmentProcRecordPtr): LONGINT;
  548.  INLINE $203C,$1E,$4F,$AAA3;
  549.  
  550. FUNCTION SetCSequenceDataRateParams(seqID: ImageSequence; params: DataRateParamsPtr): OSErr;
  551.  INLINE $203C,$8,$50,$AAA3;
  552. FUNCTION SetCSequenceFrameNumber(seqID: ImageSequence; frameNumber: LONGINT): OSErr;
  553.  INLINE $203C,$8,$51,$AAA3;
  554. FUNCTION NewImageGWorld(VAR gworld: GWorldPtr; idh: ImageDescriptionHandle; flags :GWorldFlags): OSErr;
  555.  INLINE $203C,$C,$52,$AAA3;
  556. FUNCTION GetCSequenceDataRateParams(seqID: ImageSequence; params: DataRateParamsPtr): OSErr;
  557.  INLINE $203C,$8,$53,$AAA3;
  558. FUNCTION GetCSequenceFrameNumber(seqID: ImageSequence; VAR frameNumber: LONGINT): OSErr;
  559.  INLINE $203C,$8,$54,$AAA3;
  560. FUNCTION GetBestDeviceRect(VAR gdh: GDHandle; VAR rp: Rect): OSErr;
  561.  INLINE $203C,$8,$55,$AAA3;
  562.  
  563.  
  564. CONST
  565.  identityMatrixType            = $00;                         { result if matrix is identity }
  566.  translateMatrixType        = $01;                         { result if matrix translates }
  567.  scaleMatrixType            = $02;                         { result if matrix scales }
  568.  scaleTranslateMatrixType    = $03;                         { result if matrix scales and translates }
  569.  linearMatrixType            = $04;                         { result if matrix is general 2 x 2 }
  570.  linearTranslateMatrixType    = $05;                         { result if matrix is general 2 x 2 and translates }
  571.  perspectiveMatrixType        = $06;                         { result if matrix is general 3 x 3 }
  572.  
  573.  
  574. FUNCTION GetMatrixType( m: MatrixRecord): INTEGER;
  575.  INLINE $7014,$ABC2;
  576. PROCEDURE CopyMatrix(m1: MatrixRecord;VAR m2: MatrixRecord);
  577.  INLINE $7020,$ABC2;
  578. FUNCTION EqualMatrix(m1: MatrixRecord; m2: MatrixRecord): BOOLEAN;
  579.  INLINE $7021,$ABC2;
  580. PROCEDURE SetIdentityMatrix(VAR matrix: MatrixRecord);
  581.  INLINE $7015,$ABC2;
  582. PROCEDURE TranslateMatrix(VAR m: MatrixRecord;deltaH: Fixed;deltaV: Fixed);
  583.  INLINE $7019,$ABC2;
  584. PROCEDURE RotateMatrix(VAR m: MatrixRecord;degrees: Fixed;aboutX: Fixed;
  585.  aboutY: Fixed);
  586.  INLINE $7016,$ABC2;
  587. PROCEDURE ScaleMatrix(VAR m: MatrixRecord;scaleX: Fixed;scaleY: Fixed;aboutX: Fixed;
  588.  aboutY: Fixed);
  589.  INLINE $7017,$ABC2;
  590. PROCEDURE SkewMatrix(VAR m: MatrixRecord;skewX: Fixed;skewY: Fixed;aboutX: Fixed;
  591.  aboutY: Fixed);
  592.  INLINE $7018,$ABC2;
  593. FUNCTION TransformFixedPoints( m: MatrixRecord;VAR fpt: FixedPoint;count: LONGINT): OSErr;
  594.  INLINE $7022,$ABC2;
  595. FUNCTION TransformPoints( mp: MatrixRecord;VAR pt1: Point;count: LONGINT): OSErr;
  596.  INLINE $7023,$ABC2;
  597. FUNCTION TransformFixedRect( m: MatrixRecord;VAR fr: FixedRect;VAR fpp: FixedPoint): BOOLEAN;
  598.  INLINE $7024,$ABC2;
  599. FUNCTION TransformRect( m: MatrixRecord;VAR r: Rect;VAR fpp: FixedPoint): BOOLEAN;
  600.  INLINE $7025,$ABC2;
  601. FUNCTION TransformRgn( mp: MatrixRecord;r: RgnHandle): OSErr;
  602.  INLINE $7039,$AAA3;
  603. FUNCTION InverseMatrix(m: MatrixRecord; VAR im: MatrixRecord): BOOLEAN;
  604.  INLINE $701C,$ABC2;
  605. PROCEDURE ConcatMatrix(a: MatrixRecord;VAR b: MatrixRecord);
  606.  INLINE $701B,$ABC2;
  607. PROCEDURE RectMatrix(VAR matrix: MatrixRecord; srcRect: Rect; dstRect: Rect);
  608.  INLINE $701E,$ABC2;
  609. PROCEDURE MapMatrix(VAR matrix: MatrixRecord; fromRect: Rect; toRect: Rect);
  610.  INLINE $701D,$ABC2;
  611.  
  612.  
  613. {$ENDC} { UsingImageCompression }
  614.  
  615. {$IFC NOT UsingIncludes}
  616.  END.
  617. {$ENDC}
  618.